(defresolver `entity-autocomplete
  {::pc/output [{:entity/autocomplete
                 [::autocomplete/group-key
                  ::autocomplete/group-entity-type
                  {::autocomplete/items {:entity.type/company [:company/id :company/name :company/website :company/description]
                                         :entity.type/contact [:company/id :contact/name :contact/email :contact/description]}}]}]}
  (fn [{:keys [ast] :as env} _]
    {::pc/env (assoc env ::p/union-path :entity/type)
     :entity/autocomplete search-results}))

(is (= (test-parser env
             [{'(:entity/autocomplete {:filter-value "Av"})
               [::autocomplete/group-key
                ::autocomplete/group-entity-type
                ::autocomplete/items {:entity.type/contact [:contact/id :entity/type]
                                      :entity.type/company [:company/id :entity/type]}]}])

           [{::autocomplete/group-entity-type :entity.type/company
             ::autocomplete/group-key :atlas-crm.domain.autocomplete.group-key/search-results
             ::autocomplete/items [{:company/id 1
                                    :company/name "Avisi"
                                    :entity/type :entity.type/company}]}]))

::p/union-path :entity/type

(defn default-union-path [{:keys [query] :as env}]
  (let [e (entity env)]
    (if-let [path (some->> (keys query)
                           (filter #(contains? e %))
                           first)]
      path)))

(def parser
  (p/parser
    {::p/mutate  server/server-mutate
     ::p/plugins [(p/env-wrap-plugin (fn [env]
                                       (assoc env ::pc/indexes @indexes)))
                  (p/env-plugin {::p/reader               [p/map-reader
                                                           pc/all-readers
                                                           (p/placeholder-reader ">")]
                                 ::p/placeholder-prefixes #{">"}
                                 ::pc/mutation-join-globals [::prim/tempids]
                                 ::pc/resolver-dispatch   resolver-fn})
                  p/request-cache-plugin
                  pp/profile-plugin
                  (preprocess-parser-plugin log-requests)
                  (preprocess-parser-plugin add-current-info)
                  (p/post-process-parser-plugin p/elide-not-found)]}))

(defmutation new-wash
  [{:keys [wash-id]}]
  (with [env] s.policy/existence)
  (action [{:keys [db conn current/firm current/user]}]
    (let [db-id (wash/create conn {:org-id  (:db/id firm)
                                               :user-id (:db/id user)})]
      {::prim/tempids {wash-id db-id}})))

(def error-handler-plugin
  {::wrap-read   wrap-handle-exception
   ::wrap-parser wrap-parser-exception
   ::wrap-mutate wrap-mutate-handle-exception})

(def http-global-status-plugin
  {::p/wrap-parser
   (fn [parser]
     (fn [env tx]
       (let [status-atom (atom nil)
             result (parser (assoc env ::http-status status-atom) tx)]
         (cond-> result
           @status-atom (assoc :http-status @status-atom)))))})

#:ucv.ui.mobile-pos.screens.camera{new-wash-&-unconfirmed-vehicle
                                   {:error "Unauthorized Request",
                                    :fulcro.incubator.pessimistic-mutations/mutation-errors
                                    "Unauthorized Request",
                                    :status 401,
                                    :body
                                    {:message
                                     "mutation ucv.ui.mobile-pos.screens.camera/new-wash-&-unconfirmed-vehicle unauthorized, s.policy/fail violated"}}}

(p/post-process-parser-plugin
  (fn [input]
    (js/console.log "input" input)
    input))

(df/load reconciler [:foo/by-id 0] Foo {})

(defn fulcro-ident-reader
  [{:keys [ast state] :as env}]
  (let [{:keys [key component]} ast
        state-map               @state
        extra-content           (get-in ast [:params :pathom/context])
        entity                  (get-in state-map key)]
    (if (vector? key)
      (let [entity-with-extra (merge entity extra-content)]
        ;; Problem is, sometimes entity has this shape:
        ;; {:foo/id 0 :foo/bar [:bar/by-id 1]}
        ;; and I get an error in the value complaining about the value of`:foo/bar`
        ;; not being a sequence. I'm guessing it's trying to access the ident as a map
        (p/join (atom entity-with-extra) env))
      ::p/continue)))

(pc/defresolver foo-by-id->id [_ {:foo/keys [by-id]}]
  {::pc/input  #{:foo/by-id}
   ::pc/output [:foo/id]}
  {:foo/id by-id})

(pc/defresolver foo-id->by-id [_ {:foo/keys [id]}]
  {::pc/input  #{:foo/id}
   ::pc/output [:foo/by-id]}
  {:foo/by-id id})

::p/union-path (fn [{:keys [query] :as env}]
                               (let [e (p/entity env)]
                                 (:union-key e)))

[{(ucv.ui.mobile-pos.screens.camera/new-wash-&-unconfirmed-vehicle
   {:file-id #uuid "a4028c1a-efdc-48f5-88aa-c0cf1b3015d3",
    :wash {:wash/id #uuid "53988eca-da63-424c-af8c-f1c67f4c8b26"}})
  [*]}]

(pc/defresolver batched-resolver [env items]
  {::pc/input     #{:id}
   ::pc/output    [:id :name]
   ::pc/transform pc/transform-batch-resolver}
  (mapv #(get db (:id %)) items))

23:52:51.709 ERROR formiguinhas-service.parser - handler #error {
 :cause Call to #'com.wsscode.pathom.connect/pick-resolver did not conform to spec.

(.toString xx)
Evaluation error (StackOverflowError) at java.util.regex.Pattern$Branch.match (Pattern.java:4736).
null
(.getMessage xx)
=> "Call to #'com.wsscode.pathom.diplomat.http/request did not conform to spec."

(stest/unstrument '[com.wsscode.pathom.connect/pick-resolver
                    com.wsscode.pathom.connect/register
                    com.wsscode.pathom.connect/add
                    com.wsscode.pathom.diplomat.http/request])

[:cow/name {:>/farmer [:farmer/name]}]

(def db
  (atom {:users [{:id 1}]}))

(pc/defresolver user-resolver [{:keys [database] :as env} {:keys [user/id]}]
  {::pc/input  #{:user/id}
   ::pc/output [:user/id]}
  (let [user (first (filter #(= (:id %) id)) (:users database))]
    {:user/id (:id user)}))

(def app-registry [user-resolver])

(def parser
  (p/parallel-parser
   {::p/env     {::p/reader               [p/map-reader
                                           pc/parallel-reader
                                           pc/open-ident-reader
                                           p/env-placeholder-reader]
                 ::p/placeholder-prefixes #{">"}}
    ::p/mutate  pc/mutate-async
    ::p/plugins [(pc/connect-plugin {::pc/register app-registry})
                 p/error-handler-plugin
                 p/request-cache-plugin
                 p/trace-plugin]}))

(<!! (parser {:database @db} [{[:user/id 3] [:user/id]}])) => {[:user/id 3] #:user{:id 3}}

[{:my-users-paginated
  [{:pagination/items
    [:name :email :address]}
   :pagination/cursor]}]

[{(:my-users-paginated {:pagination/cursor ...})
  [{:pagination/items
    [:name :email :address]}
   :pagination/cursor]}]

(pc/defmutation login [env {:keys [connection nickname password]}]
  {::pc/sym 'login
   ....})

(def my-app-registry [login])

(def parser
  (p/parallel-parser
    {::p/env {...}
     ::p/mutate pc/mutate-async
     ::p/plugin [(pc/connect-plugin {::pc/register my-app-registry})
                 ...]}))

value (case type
                          :call
                          (do
                            (assert mutate "Parse mutation attempted but no :mutate function supplied")
                            (let [{:keys [action]} (mutate env key params)]
                              (if action
                                (try
                                  (action)
                                  (catch #?(:clj Throwable :cljs :default) e
                                    {::error e})))))

(defn mutate-async
  "Async mutate function to integrate connect mutations to pathom parser."
  [{::keys [indexes mutate-dispatch mutation-join-globals]
    :keys  [query]
    :or    {mutation-join-globals []}
    :as    env} sym' input]
  (if-let [{::keys [sym]} (get-in indexes [::index-mutations sym'])]
    (let [env (assoc-in env [:ast :key] sym)]
      {:action #(go-catch
                  (let [res (<?maybe (mutate-dispatch (assoc env ::source-mutation sym') input))]
                    (if query
                      (merge (select-keys res mutation-join-globals)
                             (<? (p/join (atom res) env)))
                      res)))})
    (throw (ex-info "Mutation not found" {:mutation sym'}))))

(def parser
  (p/parser {::p/env     {::p/reader [p/map-reader pc/reader2 pc/open-ident-reader p/env-placeholder-reader]
                          ::p/placeholder-prefixes #{">"}
                          ::p/process-error process-error
                          ::p/fail-fast? true}
             ::p/mutate  pc/mutate
             ::p/plugins [(pc/connect-plugin {::pc/register app-registry})
                          p/request-cache-plugin
                          p/trace-plugin
                          p/error-handler-plugin]}))

(pc/defresolver person-by-eid [{:keys [db] :as env} {:keys [db/id]}]
  {::pc/input #{:db/id}
   ::pc/output [:person/full-name]}
  (d/pull db [:person/full-name] id))

(pc/defresolver club-by-eid [{:keys [db] :as env} {:keys [db/id]}]
  {::pc/input #{:db/id}
   ::pc/output [:club/name :person/full-name]}
  (let [club      (d/pull db [:club/name :club/manager] id)
        full-name (d/pull db [:person/full-name] (get-in club [:club/manager :db/id]))]
    (assoc club :club/manager-full-name full-name)))

(pc/defresolver club-by-eid [{:keys [db] :as env} {:keys [db/id]}]
  {::pc/input #{:db/id}
   ::pc/output [:club/name :person/full-name]}
  (let [club      (d/pull db [:club/name :club/manager] id)
        full-name (d/pull db [:person/full-name] (get-in club [:club/manager :db/id]))]
    (merge club full-name)))

(pc/defresolver person-by-id [{:keys [db] :as env} {:keys [person/id]}]
  {::pc/input #{:person/id}
   ::pc/output [:db/id]}
  (let [eid (first (first (d/q '[:find ?e
                                 :in $ ?id
                                 :where [?e :person/id ?id]]
                               db id)))]
    {:db/id eid}))

(pc/defresolver person-by-eid [{:keys [db] :as env} {:keys [db/id]}]
  {::pc/input #{:person/id}
   ::pc/output [:person/id :person/full-name :club/id]}
  (let [res (d/pull db [:person/id :person/full-name {:club/_manager [:club/id]}] id)]
    (-> res
        (assoc :club/id (get-in res [:club/_manager :club/id]))
        (dissoc :club/_manager))))

(pc/defresolver club-by-id [{:keys [db] :as env} {:keys [db/id]}]
  {::pc/input #{:club/id}
   ::pc/output [:club/id :club/name :person/id]}
  (let [res (d/pull db [:club/id :club/name {:club/manager [:person/id]}] id)]
    (-> res
        (assoc :club/id (get-in res [:club/manager :person/id]))
        (dissoc :club/manager))))

clojure
(pc/defresolver person-resolver [_ _]
  {::pc/input  #{:person/id}
   ::pc/output [:person/name :person/age]}
  (let [person (pull-person ...)]
    (merge
      {:person/name nil :person/age nil}
      person)))

fulcro-http-remote

(def server-parser #(a/<!! (p/parser % %2)))

java.lang.Exception: Not supported: class java.lang.Class

#:cawala.api.mutations{delete-person
                       #:com.wsscode.pathom.core{:reader-error
                                                 java.lang.NullPointerException}}

m/delete-person

`[(delete-person {:list-id 1 :person-id 1})]

{:spacex.launch/all-videos 
 [{:spacex.launch/video-url "..."}
  {:spacex.launch/video-url "..."}
  {:spacex.launch/video-url "..."}]}

{:pc/input #{:pagination/limit}
 :pc/output [{:user/all ....}]}

(pc/defmutation test-mutation [env params]
  {::pc/sym    'test-mutation
   ::pc/params [:test-tempid]
   ::pc/output [:test-id]}
  (let [test-id (.toString (java.util.UUID/randomUUID))]
    (println "IN MUTATION")
    {:test-id test-id}))

(defn make-parser []
  (p/parser
    {::p/env {::p/reader               [p/map-reader
                                        pc/parallel-reader
                                        pc/open-ident-reader
                                        p/env-placeholder-reader]
              ::p/placeholder-prefixes #{">"}}
             ::p/mutate pc/mutate
             ::p/plugins [(pc/connect-plugin {::pc/register [test-mutation]})
                          p/error-handler-plugin
                          p/request-cache-plugin
                          p/trace-plugin]}))

((make-parser) {} `[(test-mutation {:test-tempid "12345678"})])

(def my-mutations
  [{::pc/sym 'test/test-mutation
    ::pc/params [:test-tempid]
    ::pc/output [:test-id]
    ::pc/mutation (fn [env params]
                    (let [test-id (.toString (java.util.UUID/randomUUID))]
                      (println "IN MUTATION")
                      {:test-id test-id}))}])

(my-p {}
      `[(test/test-mutation {:test-tempid "12345678"})])

#:com.wsscode.pathom.connect{:sym test/test-mutation, :params [:test-tempid], :output [:test-id] ...}

(def my-mutations
  [{::pc/sym 'test/test-mutation
    ::pc/params [:test-tempid]
    ::pc/output [:test-id]
    ::pc/mutation (fn [env params]
                    (let [test-id (.toString (java.util.UUID/randomUUID))]
                      (println "IN MUTATION")
                      {:test-id test-id}))}])

(my-p {}
      `[(test/test-mutation {:test-tempid "12345678"})])

[{:current-user [:user/id :user/first-name]}]

{:current-user
 {:user/first-name "Henri",
  :user/id #uuid "2d3f8164-9a7c-45b6-b0ef-194cfd5b84be"}}

[{:current-user [:user/id {:>details [:user/first-name]}]}]

{:current-user
 {:user/id #uuid "2d3f8164-9a7c-45b6-b0ef-194cfd5b84be", :>details {}}}

(pc/defresolver my-resolver [_ _]
  {...
   ::pc/transform (fn [resolver-map]
                    (update resolver-map ::pc/resolve
                      (fn [resolve]
                        (fn [env input]
                          (let [res
                                (resolve
                                  (assoc env :modified "env")
                                  (assoc input :input-extra "change-input"))]
                            (assoc res :change-output "too"))))))})

;                                                 v
 (d/pull db '[:node/id :node/mass {:node/neighbors 2}] ent-id)

(def mock-db
  {:node/id {0 {:node/id 0 :node/mass 0.00 :node/neighbors [{:node/id 1}]}
             1 {:node/id 1 :node/mass 1.11 :node/neighbors [{:node/id 2}]}
             2 {:node/id 2 :node/mass 2.22 :node/neighbors [{:node/id 3}]}
             3 {:node/id 3 :node/mass 3.33 :node/neighbors [{:node/id 0}]}}})

(def mock-db
  {:node/id {0 {:node/id 0 :node/mass 0.00 :node/neighbors {:node/id 1}}
             1 {:node/id 1 :node/mass 1.11 :node/neighbors {:node/id 2}}
             2 {:node/id 2 :node/mass 2.22 :node/neighbors {:node/id 3}}
             3 {:node/id 3 :node/mass 3.33 :node/neighbors {:node/id 0}}}})

edn
[({[:preference-list/by-slug "was-sollen-wir-mit-20-000eur-anfangen"]
   [:dbas.issue/slug {:preferences [{:position [:id :text :cost]}]}]}
  {:token "****"})]

clojure
(pc/defresolver preferences [{{{:keys [token]} :params} :ast} {slug :preference-list/by-slug}]
  {::pc/input #{:preference-list/by-slug}
   ::pc/output [:dbas.issue/slug {:preferences [:position [:id :text :cost]]}]}
 ....)

[{([:preference-list/by-slug "was-sollen-wir-mit-20-000eur-anfangen"] {:token "****"})
  [:dbas.issue/slug {:preferences [{:position [:id :text :cost]}]}]}]

(def token-param-plugin
  {::p/wrap-read
   (fn [reader]
     (fn [env]
       (let [token (get-in env [:ast :params :])]
         (reader (cond-> env token (assoc : token))))))})

{::p/env {::p/reader               [p/map-reader
                                        pc/parallel-reader
                                        pc/open-ident-reader
                                        p/env-placeholder-reader]
              ::p/placeholder-prefixes #{">"}}
             ::p/mutate pc/mutate
             ::p/plugins [(pc/connect-plugin {::pc/register (concat parser-mutations/mutations parser-queries/queries)})
                          p/error-handler-plugin
                          p/request-cache-plugin
                          p/trace-plugin]}))

(def sync-parser [env tx]
  (clojure.core.async/<!! (real-parser env tx)))

(pc/defresolver user-data [env params]
  {::pc/input  #{:db/id}
   ::pc/output [{:user [:user/name :user/email]}]}
  ...)

(pc/defresolver current-user [env params]
  {::pc/output [{:user [:db/id :user/authenticated?]}]}
  {:user {:db/id               123
          :user/authenticated? true}})

(my-parser [{:user [:db/id :user/authenticated? :user/name :user/email]}]) =>

{:user {:db/id 123, :user/authenticated? true, :user/name :com.wsscode.pathom.core/not-found, :user/email :com.wsscode.pathom.core/not-found}}

(pc/defresolver user-data [env params]
  {::pc/input  #{:db/id}
   ::pc/output [:user/name :user/email]}
  ...)

(my-parser [{:user [:db/id :user/authenticated? {:use [r:user/name :user/email]}]}])

(pc/defresolver user-data [env params]
  {::pc/input  #{:db/id}
   ::pc/output [:user/name :user/email]}
  ...)

(pc/defresolver user-data [env params]
  {::pc/input  #{:user/id}
   ::pc/output [:user/name :user/email]}
  ...)

(pc/defresolver current-user [env params]
  {::pc/output [{:current-user [:user/id :user/authenticated?]}]}
  {:current-user {:user/id               123
                  :user/authenticated? true}})

(my-parser [{:current-user [:user/id :user/authenticated? :user/name :user/email]}])

[{(ucv.ui.receipt/print-receipt
   {:remote :rest,
    :order/id #uuid "4eb5af84-1611-4d79-8c3b-4acf919e1e82"}) 
  [*]}]

(pc/defresolver print-receipt [{:keys [app-atom ast]} {:keys [firm order]}]
  {#_#_::pc/params [:firm :order]
   ::pc/output [:receipt-printer/success]}
  (util/spy firm order)
  (go-catch
    (let [controller-api ""
          response       (async/<! (http/post controller-api
                                     {:body              (transit-clj->str
                                                           {:firm firm :order order})
                                      :with-credentials? false}))]
      (util/spy :pp (transit-str->clj (:body response))))))

(defn rest-parser
  "Create a REST parser. Make sure you've required all nses that define rest resolvers. The given app-atom will be available
  to all resolvers in `env` as `:app-atom`."
  [app-atom]
  (p/parallel-parser
    {::p/env     {::p/reader               [p/map-reader
                                            pc/parallel-reader
                                            pc/open-ident-reader
                                            p/env-placeholder-reader]
                  ::p/placeholder-prefixes #{">"}}
     ::p/mutate  pc/mutate-async
     ::p/plugins [(p/env-plugin {:app-atom app-atom})
                  (pc/connect-plugin {::pc/register (vec (vals @pathom-registry))})
                  p/error-handler-plugin
                  p/request-cache-plugin
                  (p/post-process-parser-plugin p/elide-not-found)]}))

(comment
  (go-catch
    (util/spy (async/<! ((rest-parser) {}
                          '[(ucv.ui.receipt/print-receipt {})])))))

; create a index outside so you can maintain it
(defonce indexes (atom {}))

(def parser
  (p/parallel-parser
    {::p/env     {::p/reader               [p/map-reader
                                            pc/parallel-reader
                                            pc/open-ident-reader
                                            p/env-placeholder-reader]
                  ::p/placeholder-prefixes #{">"}}
     ::p/mutate  pc/mutate-async
     ::p/plugins [(pc/connect-plugin {::pc/register my-resolvers
                                      ; send your index here
                                      ::pc/indexes indexes})
                  p/error-handler-plugin
                  p/trace-plugin]}))

clojure
(pc/defresolver foo [_ {id :foo/by-id}]
  {::pc/input #{:foo/by-id}
   ::pc/output [:foo/id :foo/name]
  {:foo/id id :foo/name (str "Foo_" id}))

(pc/defresolver bars [_ _]
  {::pc/output [{:bars foo}]  <-- or like prim/get-query in fulcro
  {:bars [[:foo/by-id 1] [:foo/by-id 2]]}

edn
[{:bars [:foo/name]}]

Results in:
[{:bars [{:foo/name "Foo_1"}
         {:foo/name "Foo_2"}]}]

[{:bars [:foo/id]}]

{:bars [{:foo/id 1} {:foo/id 2}]}

(pc/defresolver bars [_ _]
 {::pc/output [{:bars [:foo/id]}]
 {:bars [{:foo/id 1} {:foo/id 2}]}

{:foo/by-id {1 {:foo/id 1}}}

:cause "class clojure.lang.Keyword cannot be cast to class clojure.lang.IObj (clojure.lang.Keyword and clojure.lang.IObj are in unnamed module of loader 'app')"
 :via
 [{:type java.lang.ClassCastException
   :message "class clojure.lang.Keyword cannot be cast to class clojure.lang.IObj (clojure.lang.Keyword and clojure.lang.IObj are in unnamed module of loader 'app')"
   :at [clojure.core$with_meta__5405 invokeStatic "core.clj" 217]}]
 :trace
 [[clojure.core$with_meta__5405 invokeStatic "core.clj" 217]
  [clojure.core$with_meta__5405 invoke "core.clj" 217]
  [com.wsscode.pathom.core$elide_items invokeStatic "core.cljc" 219]
  [com.wsscode.pathom.core$elide_items invoke "core.cljc" 216]

(server/handle-api-request
                         parser
                         ;; this map is `env`. Put other defstate things in this map and they'll be
                         ;; added to the resolver/mutation env.
                         {:ring/request request}
                         (:transit-params request))]

(defresolver entity-resolver
  "Resolves query for an entity"
  [{:keys [conn tx] :as env} {:keys [company/by-id] :as input}]
  {::pc/input  #{:company/by-id}
   ::pc/output [:db/id :company/name]}
  (d/pull (d/db conn) '[*] by-id))

{:event "reset-loop",
                                       :duration 0,
                                       :start 4,
                                       :loop-keys [:com.wsscode.pathom/trace]}
                                      {:event "process-pending",
                                       :duration 0,
                                       :start 51,
                                       :provides #{[:fm.user/id #uuid"156e2937-5cf9-46fa-bbe6-8e9d9e1f3780"]},
                                       :merge-result? true}

:key :fm.user/first-name}
                                                              {:event "call-resolver",
                                                               :duration 5061,
                                                               :start 2,
                                                               :label :fm/user,
                                                               :input-data #:fm.user{:id #uuid"156e2937-5cf9-46fa-bbe6-8e9d9e1f3780"},
                                                               :sym :fm/user,
                                                               :key :fm.user/first-name}

(parser {} [{(add-foo ..) [:foo/id]}])
(parser {} [{[:foo/id ...] [:foo/bar :foo/baz]}])
; - instead of 
(parser {} [{{(add-foo ..)[:foo/bar :foo/baz]}])

;; 1
[{(add-value) [:app/value]}]
;; 2
[(add-value)
   :app/value]

(my-ns
  (:require [com.wsscode.pathom.graphql :as pg]))

(pg/query->graphql [{:foo [:bar]}])
;; => "query { foo { bar } }"

(def parser
  (p/parallel-parser
    {::p/env     {::p/reader               [p/map-reader
                                            pc/all-parallel-readers
                                            p/env-placeholder-reader]
                  ::p/placeholder-prefixes #{">"}}
     ::p/mutate  pc/mutate-async
     ::p/plugins [(pc/connect-plugin {::pc/register my-registers})
                  p/error-handler-plugin]}))

[../has-next?
{:atlas-crm.pagination/items (prim/get-query Entity)}
           {:>/pagination (prim/get-query pagination/Pagination)}]

[:atlas-crm.pagination/has-next-page?
           :atlas-crm.pagination/has-previous-page?
           :atlas-crm.pagination/size
           {:atlas-crm.pagination/items [:atlas-crm.pagination.items/cursor]}

`:networking` (optional). An instance of FulcroNetwork that will act as the default remote (named :remote). If
  you want to support multiple remotes, then this should be a map whose keys are the keyword names of the remotes
  and whose values are FulcroNetwork instances.

(defn create-request
  [{::env/keys [graph] :as ctx}]
  (let [tx-id
        `m/create

        query
        `[(~tx-id {})]

        order-id
        (-> (graph ctx query)
            (get tx-id)
            (get ::m/order-id))]

    ;; use order-id ...
    ))

[{[:foo/ident 123]
  [(foo/do-something {})]}]

[{:customer/all-tags [(customer.tag/delete)]}]

(pc/defresolver people-resolver [env _]
  {::pc/output [{:people [:person/name]}]}
  {:people [{:person/name "Tom"}
            {:person/name "Tal"}
            {:person/name "Lita"}]})

(pc/defmutation do-something [env input]
  {}
  (println "DO SOMETHING" input (p/entity env))
  {})

(parser {} [{:people [:person/name `(do-something)]}])

DO SOMETHING {} #:person{:name Tom}
DO SOMETHING {} #:person{:name Tal}
DO SOMETHING {} #:person{:name Lita}
=>
{:people [{:person/name "Tom", com.wsscode.pathom.playground/do-something {}}
          {:person/name "Tal", com.wsscode.pathom.playground/do-something {}}
          {:person/name "Lita", com.wsscode.pathom.playground/do-something {}}]}

(def auth-plugin
  {::p/wrap-parser
   (fn [parser]
     (fn [env tx]
       (let [{:keys [id-token-str]} @auth]
         (parser (cond-> env
                   (seq id-token-str)
                   (assoc-in [::p.http/headers :authorization] (str "Bearer " id-token-str)))
                 tx))))})

(def parser
  (p/parallel-parser
   {::p/env {::p/reader [p/map-reader
                         pc/parallel-reader
                         pc/open-ident-reader
                         p/env-placeholder-reader]
             ::p/placeholder-prefixes #{">"}
             ::p.http/driver p.http.fetch/request-async}
    ::p/mutate pc/mutate-async
    ::p/plugins [(pc/connect-plugin {::pc/indexes indexes})
                 auth-plugin
                 p/error-handler-plugin
                 p/request-cache-plugin
                 p/trace-plugin]}))

(def inspect-plugin
  {::p/wrap-read
   (fn [reader]
     (fn [env]
       (let [ret (reader env)]
         (js/console.log {:env env :ret ret})
         ret)))})

(fp/defsc Chat [_ _]
  {:query [:chat/id
           {:chat/msg (fp/get-query Msg)}]
   :ident [:chat/id :chat/id]})

(fm/defmutation merge-page-items [{:keys  [abrams.page/items]
                                   ::keys [page-key]}]
  (action [env]
    (db.h/swap-entity! env update-in [page-key :abrams.page/items] #(into items %))))

(defn load-next-page [this {::keys [page-key load-config]}]
  (let [ref           (fp/get-ident this)
        state         (-> (fp/get-reconciler this) fp/app-state)
        cursor        (-> (fp/props this) page-key :abrams.page/next-cursor)
        current-items (get-in @state (conj ref page-key :abrams.page/items))
        load          (merge {:query                [{ref [(-> (fp/get-query this)
                                                               (fp/focus-query [page-key])
                                                               first
                                                               (list {:abrams.page/cursor cursor}))]}]
                              :post-mutation        `merge-page-items
                              :post-mutation-params {:abrams.page/items current-items
                                                     ::page-key         page-key}}
                             load-config)]
    (fp/transact! this [(list 'fulcro/load load)])))

(defn parser [env query]
  (if utils/dev?
    ((create-parser) env query)
    (parser-inst env query)))

Mon Apr 15 20:12:10 CEST 2019 [worker-2] ERROR - POST /api
java.lang.RuntimeException: java.lang.Exception: Not supported: class com.wsscode.pathom.trace$fn__15355
	at com.cognitect.transit.impl.WriterFactory$1.write(WriterFactory.java:65)
	at cognitect.transit$write.invokeStatic(transit.clj:167)
	at cognitect.transit$write.invoke(transit.clj:164)
...

(parser {} [{:t/data [:t/id :t/text :t/test_train :t/label]}])

#:t{:data #:com.wsscode.pathom.parser{:provides #{:t/data},
                                      :response-stream #object[clojure.core.async.impl.channels.ManyToManyChannel
                                                               0x70c6abd9
                                                               "

(def data [{:t/id         1
            :t/text       "asadad"
            :t/test_train "train"
            :t/label      "a"}
           {:t/id         2
            :t/text       "assdgsd vvdad"
            :t/test_train "train"
            :t/label      "b"}
           {:t/id         3
            :t/text       "asadadw kjonjo"
            :t/test_train "test"
            :t/label      "c"}])

(defn mk-resolver []
  {::pc/sym     (symbol "my-ns" "my-resolver")
   ::pc/output  [{:t/data [:t/id :t/text :t/test_train :t/label]}]
   ::pc/resolve (fn [_ _] {:t/data data})
   })

(defn mk-index []
  (-> {} (pc/register (mk-resolver))))

(def parser
  (p/parser
    {::p/env     {::p/reader               [p/map-reader
                                            pc/parallel-reader
                                            pc/open-ident-reader
                                            p/env-placeholder-reader]
                  ::p/placeholder-prefixes #{">"}}
     ::p/plugins [(pc/connect-plugin {::pc/indexes (atom (mk-index))})
                  p/error-handler-plugin
                  p/request-cache-plugin
                  p/trace-plugin]}))

(def limit-plugin
  {::p/wrap-read
   (fn [reader]
     (fn [env]
       (if-let [limit (-> env :ast :params ::limit)] ; use qualified keyword so it doesn't clash with other people things
         ; let-chan only required to support async/parallel parsers
         (let-chan [res (reader env)]
           (if (sequential? res)
             (vec (take limit res))
             res))
         (reader env))))})

::pc/transform pc/transform-batch-resolver

[INFO] [talledLocalContainer] Caused by: java.lang.Exception: Not supported: class com.wsscode.pathom.connect$batch_resolver$fn__36671                                                               
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.AbstractEmitter.marshal(AbstractEmitter.java:194) [?:?]                                                                                
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.JsonEmitter.emitMap(JsonEmitter.java:171) [?:?]                                                                                        
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.AbstractEmitter.emitMap(AbstractEmitter.java:85) [?:?]                                                                                 
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.AbstractEmitter.marshal(AbstractEmitter.java:184) [?:?]                                                                                
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.JsonEmitter.emitMap(JsonEmitter.java:171) [?:?]                                                                                        
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.AbstractEmitter.emitMap(AbstractEmitter.java:85) [?:?]                                                                                 
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.AbstractEmitter.marshal(AbstractEmitter.java:184) [?:?]                                                                                
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.JsonEmitter.emitMap(JsonEmitter.java:171) [?:?]                                                                                        
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.AbstractEmitter.emitMap(AbstractEmitter.java:85) [?:?]                                                                                 
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.AbstractEmitter.marshal(AbstractEmitter.java:184) [?:?]                                                                                
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.JsonEmitter.emitMap(JsonEmitter.java:171) [?:?]                                                                                        
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.AbstractEmitter.emitMap(AbstractEmitter.java:85) [?:?]                                                                                 
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.AbstractEmitter.marshal(AbstractEmitter.java:184) [?:?]                                                                                
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.AbstractEmitter.emitArray(AbstractEmitter.java:97) [?:?]                                                                               
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.AbstractEmitter.marshal(AbstractEmitter.java:182) [?:?]                                                                                
[INFO] [talledLocalContainer]   at com.cognitect.transit.impl.AbstractEmitter.emitTagged(AbstractEmitter.java:49) [?:?]                                                                             

(def my-resolver
  {::pc/input #{...}
   ::pc/output [...]
   ::pc/resolve (fn [env input] ...)}

[{(gql/build-thing {:columns [id name description]}) [:clientMutationId]}]

mutation {
  build-thing(columns: ["id","name","description"]) {
    clientMutationId
  }
}

mutation {
  build-thing(columns: [id, name, description]) {
    clientMutationId
  }
}

{::pc/input  [:utc-time/now :current-user/email]
 ::pc/params [:arg1 :arg2]
 ::pc/output [:model/id]}

(pc/defmutation do-thing [{:keys [parser] :as env} _]
  {::pc/sym 'user/do-thing}
  (let [user-name (parser env [:current-user/name])]
    ...))